#include <vector>
#include <numeric>
#include <algorithm>
#include <iostream>

using namespace std;

/*
arr1 = 1 2 3 1 1 1 <- 分六组 每个元素不同 sum(arr1) = 9
      [3, 3, 3]
9 / arr1.size() -> 9 / 6 = 是分数 -> 这就表示 arr1 这个数组不可能分成 6 组的情况下，所有元素一样

9 / 5 = 分数 -> arr1 这个数组不可能分成 5 组的情况下，所有元素一样

9 / 4

9 / 3

如果一个数组最终能变成所有元素都一样，那么这个都一样的值 n 有什么规律，有什么特点？

n 应该是这个数组所有元素和的一个因数

怎么样才能步数最少？

以数组中所有元素都相同为前提，分组数越多，需要的步骤数就越少

int s = sum(arr)

s / arr.size() 是分数
*/

// 找到分组的数量

void solution(const vector<int> &counters) {
  // 第一步，把分组的数量打印在屏幕上
  // 1.1 计算 counter 的元素和
  // 1.2 从 counter.size() 开始检查，直到遇到第一个 counter 元素和的因数

  int s = accumulate(counters.begin(), counters.end(), 0);

  for (int r = counters.size(); r > 0; --r) {
    // 如何判断 r 是 s 的因数呢？

    if (s % r == 0) {
      // counters 这个数组有可能分成 r 组，并且每个元素都相同
      // [x, x, x, ... , x] r 
      int x = s / r;
      bool is_ok = true;

      // 把 counters 中的每个元素都变成 x，需要的步数
      // int prefix = 0;
      // prefix + arr[j] > x
      // prefix 无论如何都加不到 x -> 尝试下一轮找因数 -> is_ok = false
      // prefix + arr[j] < x -> 继续加 arr[j]
      // prefix + arr[j] == x -> prefix = 0
      // 1 1 1 1 2 3
      //       ^j
      //
      
      if (is_ok) {

      }

      // 如果变不成
    }
  }
}

int main(int argc, char const *argv[])
{
  /* code */
  return 0;
}
